home *** CD-ROM | disk | FTP | other *** search
/ Cream of the Crop 26 / Cream of the Crop 26.iso / program / nasm095.zip / RDOFF / LDRDF.C < prev    next >
C/C++ Source or Header  |  1997-07-27  |  20KB  |  727 lines
  1. /* ldrdf.c    RDOFF Object File linker/loader main program
  2.  *
  3.  * The Netwide Assembler is copyright (C) 1996 Simon Tatham and
  4.  * Julian Hall. All rights reserved. The software is
  5.  * redistributable under the licence given in the file "Licence"
  6.  * distributed in the NASM archive.
  7.  */
  8.  
  9. /* TODO: Make the system skip a module (other than the first) if none
  10.  * of the other specified modules contain a reference to it.
  11.  * May require the system to make an extra pass of the modules to be
  12.  * loaded eliminating those that aren't required.
  13.  *
  14.  * Support all the existing documented options...
  15.  *
  16.  * Support libaries (.a files - requires a 'ranlib' type utility)
  17.  *        (I think I've got this working, so I've upped the version)
  18.  *
  19.  * -s option to strip resolved symbols from exports. (Could make this an
  20.  * external utility)
  21.  */
  22.  
  23. #include <stdio.h>
  24. #include <stdlib.h>
  25. #include <string.h>
  26.  
  27. #include "nasm.h"
  28. #include "rdoff.h"
  29. #include "nasmlib.h"
  30. #include "symtab.h"
  31. #include "collectn.h"
  32. #include "rdlib.h"
  33.  
  34. #define LDRDF_VERSION "0.30"
  35.  
  36. /* global variables - those to set options: */
  37.  
  38. int     verbose = 0;    /* reflects setting of command line switch */
  39. int    align = 16;
  40. int    errors = 0;    /* set by functions to cause halt after current
  41.                stage of processing */
  42.  
  43. /* the linked list of modules that must be loaded & linked */
  44.  
  45. struct modulenode {
  46.     rdffile    f;    /* the file */
  47.     long    coderel;    /* module's code relocation factor */
  48.     long    datarel;    /* module's data relocation factor */
  49.     long    bssrel;        /* module's bss data reloc. factor */
  50.     void *    header;        /* header location, if loaded */
  51.     char *    name;        /* filename */
  52.     struct modulenode *next;
  53. };
  54.  
  55. #define newstr(str) strcpy(malloc(strlen(str) + 1),str)
  56. #define newstrcat(s1,s2) strcat(strcpy(malloc(strlen(s1)+strlen(s2)+1),s1),s2)
  57.  
  58.  
  59. struct modulenode *modules = NULL,*lastmodule = NULL;
  60.  
  61. /* the linked list of libraries to be searched for missing imported
  62.    symbols */
  63.  
  64. struct librarynode * libraries = NULL, * lastlib = NULL;
  65.  
  66. void *symtab;    /* The symbol table */
  67.  
  68. rdf_headerbuf * newheader ;    /* New header to be written to output */
  69.  
  70. /* loadmodule - find the characteristics of a module and add it to the
  71.  *        list of those being linked together            */
  72.  
  73. void loadmodule(char *filename)
  74. {
  75.   struct modulenode *prev;
  76.   if (! modules) {
  77.     modules = malloc(sizeof(struct modulenode));
  78.     lastmodule = modules;
  79.     prev = NULL;
  80.   }
  81.   else {
  82.     lastmodule->next = malloc(sizeof(struct modulenode));
  83.     prev = lastmodule;
  84.     lastmodule = lastmodule->next;
  85.   }
  86.  
  87.   if (! lastmodule) {
  88.     fputs("ldrdf: not enough memory\n",stderr);
  89.     exit(1);
  90.   }
  91.  
  92.   if (rdfopen(&lastmodule->f,filename)) {
  93.     rdfperror("ldrdf",filename);
  94.     exit(1);
  95.   }
  96.  
  97.   lastmodule->header = NULL;    /* header hasn't been loaded */
  98.   lastmodule->name = filename;
  99.   lastmodule->next = NULL;
  100.  
  101.   if (prev) {
  102.     lastmodule->coderel = prev->coderel + prev->f.code_len;
  103.     if (lastmodule->coderel % align != 0)
  104.       lastmodule->coderel += align - (lastmodule->coderel % align);
  105.     lastmodule->datarel = prev->datarel + prev->f.data_len;
  106.     if (lastmodule->datarel % align != 0)
  107.       lastmodule->datarel += align - (lastmodule->datarel % align);
  108.   }
  109.   else {
  110.     lastmodule->coderel = 0;
  111.     lastmodule->datarel = 0;
  112.   }
  113.  
  114.   if (verbose)
  115.     printf("%s code = %08lx (+%04lx), data = %08lx (+%04lx)\n",filename,
  116.        lastmodule->coderel,lastmodule->f.code_len,
  117.        lastmodule->datarel,lastmodule->f.data_len);
  118.  
  119.   lastmodule->header = malloc(lastmodule->f.header_len);
  120.   if (!lastmodule->header) {
  121.       fprintf(stderr,"ldrdf: out of memory\n");
  122.       exit(1);
  123.   }
  124.  
  125.   if (rdfloadseg(&lastmodule->f,RDOFF_HEADER,lastmodule->header))
  126.   {
  127.       rdfperror("ldrdf",filename);
  128.       exit(1);
  129.   }
  130. }
  131.  
  132. /* load_library        add a library to list of libraries to search
  133.  *                      for undefined symbols
  134.  */
  135.  
  136. void load_library(char * name)
  137. {
  138.     if (verbose)
  139.     printf("adding library %s to search path\n",name);
  140.     
  141.     if (! lastlib) {
  142.     lastlib = libraries = malloc(sizeof(struct librarynode));
  143.     }
  144.     else
  145.     {
  146.     lastlib->next = malloc(sizeof(struct librarynode));
  147.     lastlib = lastlib->next;
  148.     }
  149.  
  150.     if (! lastlib) {
  151.     fprintf(stderr, "ldrdf: out of memory\n");
  152.     exit(1);
  153.     }
  154.     strcpy (lastlib->name = malloc (1+strlen(name)), name);
  155.     lastlib->fp = NULL;
  156.     lastlib->referenced = 0;
  157.     lastlib->next = NULL;
  158. }
  159.  
  160.  
  161. /* build_symbols()    step through each module's header, and locate
  162.  *            exported symbols, placing them in a global table
  163.  */
  164.  
  165. long bsslength;
  166.  
  167. void mod_addsymbols(struct modulenode * mod)
  168. {
  169.     rdfheaderrec *r;
  170.     symtabEnt e;
  171.     long cbBss;
  172.  
  173.     mod->bssrel = bsslength;
  174.     cbBss = 0;
  175.     rdfheaderrewind(&mod->f);
  176.     while ((r = rdfgetheaderrec(&mod->f)))
  177.     {
  178.  
  179.     if (r->type == 5)        /* Allocate BSS */
  180.         cbBss += r->b.amount;
  181.  
  182.     if (r->type != 3) continue;    /* ignore all but export recs */
  183.  
  184.     e.segment = r->e.segment;
  185.     e.offset = r->e.offset + 
  186.         (e.segment == 0 ? mod->coderel : /* 0 -> code */
  187.          e.segment == 1 ? mod->datarel : /* 1 -> data */
  188.          mod->bssrel) ; /* 2 -> bss  */
  189.     
  190.     e.flags = 0;
  191.     e.name = malloc(strlen(r->e.label) + 1);
  192.     if (! e.name)
  193.     {
  194.         fprintf(stderr,"ldrdf: out of memory\n");
  195.         exit(1);
  196.     }
  197.     strcpy(e.name,r->e.label);
  198.     symtabInsert(symtab,&e);
  199.     }
  200.     bsslength += cbBss;
  201. }
  202.  
  203. void build_symbols()
  204. {
  205.   struct modulenode *mod;
  206.  
  207.   if (verbose) printf("building global symbol table:\n");
  208.   newheader = rdfnewheader();
  209.  
  210.   symtab = symtabNew();
  211.   bsslength = 0;          /* keep track of location of BSS symbols */
  212.  
  213.   for (mod = modules; mod; mod = mod->next)
  214.   {
  215.       mod_addsymbols( mod );
  216.   }
  217.   if (verbose)
  218.   {
  219.       symtabDump(symtab,stdout);
  220.       printf("BSS length = %ld bytes\n\n",bsslength);
  221.   }
  222. }
  223.  
  224.  
  225. /* scan_libraries()    search through headers of modules for undefined
  226.  *            symbols, and scan libraries for those symbols,
  227.  *            adding library modules found to list of modules
  228.  *            to load.                    */
  229.  
  230. void scan_libraries(void)
  231. {
  232.     struct modulenode     * mod, * nm;
  233.     struct librarynode    * lib;
  234.     rdfheaderrec    * r;
  235.     int            found;
  236.     char        * tmp;
  237.  
  238.     if (verbose) printf("Scanning libraries for unresolved symbols...\n");
  239.  
  240.     mod = modules;
  241.  
  242.     while (mod)
  243.     {
  244.     rdfheaderrewind(&mod->f);
  245.  
  246.     while ((r = rdfgetheaderrec(&mod->f)))
  247.     {
  248.         if (r->type != 2) continue;    /* not an import record */
  249.         if ( symtabFind (symtab,r->i.label) )
  250.         continue;        /* symbol already defined */
  251.         
  252.         /* okay, we have an undefined symbol... step through
  253.            the libraries now */
  254.         if (verbose >= 2) {
  255.         printf("undefined symbol '%s'...",r->i.label);
  256.         fflush(stdout);
  257.         }
  258.  
  259.         lib = libraries;
  260.         found = 0;
  261.  
  262.         tmp = newstr(r->i.label);
  263.         while (! found && lib)
  264.         {
  265.         /* move this to an outer loop...! */
  266.         nm = malloc(sizeof(struct modulenode));
  267.  
  268.         if (rdl_searchlib(lib,tmp,&nm->f))
  269.         {    /* found a module in the library */
  270.  
  271.             /* create a modulenode for it */
  272.  
  273.             if (! nm) {
  274.             fprintf(stderr,"ldrdf: out of memory\n");
  275.             exit(1);
  276.             }
  277.  
  278.             nm->name = newstrcat(lib->name,nm->f.name);
  279.             if (verbose >= 2) printf("found in '%s'\n",nm->name);
  280.  
  281.             nm->coderel = lastmodule->coderel + lastmodule->f.code_len;
  282.             if (nm->coderel % align != 0)
  283.             nm->coderel += align - (nm->coderel % align);
  284.  
  285.             nm->datarel = lastmodule->datarel + lastmodule->f.data_len;
  286.             if (nm->datarel % align != 0)
  287.             nm->datarel += align - (nm->datarel % align);
  288.  
  289.             nm->header = malloc(nm->f.header_len);
  290.             if (! nm->header)
  291.             {
  292.             fprintf(stderr,"ldrdf: out of memory\n");
  293.             exit(1);
  294.             }
  295.  
  296.             if (rdfloadseg(&nm->f,RDOFF_HEADER,nm->header))
  297.             {
  298.             rdfperror("ldrdf",nm->name);
  299.             exit(1);
  300.             }
  301.  
  302.             nm->next = NULL;
  303.             found = 1;
  304.             lastmodule->next = nm;
  305.             lastmodule = nm;
  306.  
  307.             if (verbose)
  308.             printf("%s code = %08lx (+%04lx), data = %08lx "
  309.                    "(+%04lx)\n",lastmodule->name,
  310.                    lastmodule->coderel,lastmodule->f.code_len,
  311.                    lastmodule->datarel,lastmodule->f.data_len);
  312.  
  313.             /* add the module's info to the symbol table */
  314.             mod_addsymbols(nm);
  315.         }
  316.         else
  317.         {
  318.             if (rdl_error) {
  319.             rdl_perror("ldrdf",lib->name);
  320.             exit(1);
  321.             }
  322.             free(nm);
  323.         }
  324.         lib = lib->next;
  325.         }
  326.         free(tmp);
  327.         if (!found && verbose >= 2) printf("not found\n");
  328.     }
  329.     mod = mod->next;
  330.     }
  331. }
  332.  
  333. /* load_segments()    allocates memory for & loads the code & data segs
  334.  *            from the RDF modules
  335.  */
  336.  
  337. char *text,*data;
  338. long textlength,datalength;
  339.  
  340. void load_segments(void)
  341. {
  342.   struct modulenode *mod;
  343.  
  344.   if (!modules) {
  345.     fprintf(stderr,"ldrdf: nothing to do\n");
  346.     exit(0);
  347.   }
  348.   if (!lastmodule) {
  349.     fprintf(stderr,"ldrdf: panic: module list exists, but lastmodule=NULL\n");
  350.     exit(3);
  351.   }
  352.  
  353.   if (verbose)
  354.     printf("loading modules into memory\n");
  355.  
  356.   /* The following stops 16 bit DOS from crashing whilst attempting to
  357.      work using segments > 64K */
  358.   if (sizeof(int) == 2) { /* expect a 'code has no effect' warning on 32 bit
  359.                 platforms... */
  360.     if (lastmodule->coderel + lastmodule->f.code_len > 65535 ||
  361.     lastmodule->datarel + lastmodule->f.data_len > 65535) {
  362.       fprintf(stderr,"ldrdf: segment length has exceeded 64K; use a 32 bit "
  363.           "version.\nldrdf: code size = %05lx, data size = %05lx\n",
  364.           lastmodule->coderel + lastmodule->f.code_len,
  365.           lastmodule->datarel + lastmodule->f.data_len);
  366.       exit(1);
  367.     }
  368.   }
  369.  
  370.   text = malloc(textlength = lastmodule->coderel + lastmodule->f.code_len);
  371.   data = malloc(datalength = lastmodule->datarel + lastmodule->f.data_len);
  372.  
  373.   if (!text || !data) {
  374.     fprintf(stderr,"ldrdf: out of memory\n");
  375.     exit(1);
  376.   }
  377.  
  378.   mod = modules;
  379.   while (mod) {        /* load the segments for each module */
  380.       if (verbose >= 2) printf("  loading %s\n",mod->name);
  381.       if (rdfloadseg(&mod->f,RDOFF_CODE,&text[mod->coderel]) ||
  382.       rdfloadseg(&mod->f,RDOFF_DATA,&data[mod->datarel])) {
  383.       rdfperror("ldrdf",mod->name);
  384.       exit(1);
  385.       }
  386.       rdfclose(&mod->f);    /* close file; segments remain */
  387.       mod = mod->next;
  388.   }
  389. }
  390.     
  391. /* link_segments()    step through relocation records in each module's
  392.  *            header, fixing up references.
  393.  */
  394.  
  395. void link_segments(void)
  396. {
  397.   struct modulenode    *mod;
  398.   Collection        imports;
  399.   symtabEnt        *s;
  400.   long             rel,relto;
  401.   char             *seg;
  402.   rdfheaderrec        *r;
  403.   int            bRelative;
  404.  
  405.   if (verbose) printf("linking segments\n");
  406.  
  407.   collection_init(&imports);
  408.  
  409.   for (mod = modules; mod; mod = mod->next) {
  410.     if (verbose >= 2) printf("* processing %s\n",mod->name);
  411.     rdfheaderrewind(&mod->f);
  412.     while((r = rdfgetheaderrec(&mod->f))) {
  413.     if (verbose >= 3) printf("record type: %d\n",r->type);
  414.     switch(r->type) {
  415.     case 1:        /* relocation record */
  416.         if (r->r.segment >= 64) {         /* Relative relocation; */
  417.         bRelative = 1;        /* need to find location relative */
  418.         r->r.segment -= 64;        /* to start of this segment */
  419.         relto = r->r.segment == 0 ? mod->coderel : mod->datarel;
  420.         }
  421.         else
  422.         bRelative = 0;        /* non-relative - need to relocate
  423.                      * at load time            */
  424.  
  425.         /* calculate absolute offset of reference, not rel to beginning of
  426.            segment */
  427.         r->r.offset += r->r.segment == 0 ? mod->coderel : mod->datarel;
  428.  
  429.         /* calculate the relocation factor to apply to the operand -
  430.            the base address of one of this modules segments if referred
  431.            segment is 0 - 2, or the address of an imported symbol
  432.            otherwise. */
  433.  
  434.         if (r->r.refseg == 0) rel = mod->coderel;
  435.         else if (r->r.refseg == 1) rel = mod->datarel;
  436.         else if (r->r.refseg == 2) rel = mod->bssrel;
  437.         else {        /* cross module link - find reference */
  438.         s = *colln(&imports,r->r.refseg - 2);
  439.         if (!s) {
  440.             fprintf(stderr,"ldrdf: link to undefined segment %04x in"
  441.                 " %s:%d\n", r->r.refseg,mod->name,r->r.segment);
  442.             errors = 1;
  443.             break;
  444.         }
  445.         rel = s->offset;
  446.       
  447.         r->r.refseg = s->segment;    /* change referred segment, 
  448.                            so that new header is
  449.                            correct */
  450.         }
  451.  
  452.         if (bRelative)    /* Relative - subtract current segment start */
  453.         rel -= relto; 
  454.         else  
  455.         {            /* Add new relocation header */
  456.         rdfaddheader(newheader,r);
  457.         }
  458.         
  459.         /* Work out which segment we're making changes to ... */
  460.         if (r->r.segment == 0) seg = text;
  461.         else if (r->r.segment == 1) seg = data;
  462.         else {
  463.         fprintf(stderr,"ldrdf: relocation in unknown segment %d in "
  464.             "%s\n", r->r.segment,mod->name);
  465.         errors = 1;
  466.         break;
  467.         }
  468.  
  469.         /* Add the relocation factor to the datum specified: */
  470.  
  471.         if (verbose >= 3)
  472.         printf("  - relocating %d:%08lx by %08lx\n",r->r.segment,
  473.                r->r.offset,rel);
  474.  
  475.         /**** The following code is non-portable. Rewrite it... ****/
  476.         switch(r->r.length) {
  477.         case 1:
  478.         seg[r->r.offset] += (char) rel;
  479.         break;
  480.         case 2:
  481.         *(int16 *)(seg + r->r.offset) += (int16) rel;
  482.         break;
  483.         case 4:
  484.         *(long *)(seg + r->r.offset) += rel;
  485.         break;
  486.         }
  487.         break;
  488.  
  489.     case 2:        /* import record */
  490.         s = symtabFind(symtab, r->i.label);
  491.         if (s == NULL) {
  492.         /* Need to add support for dynamic linkage */
  493.         fprintf(stderr,"ldrdf: undefined symbol %s in module %s\n",
  494.             r->i.label,mod->name);
  495.         errors = 1;
  496.         }
  497.         else 
  498.         {
  499.         *colln(&imports,r->i.segment - 2) = s;
  500.         if (verbose >= 2)
  501.             printf("imported %s as %04x\n", r->i.label, r->i.segment);
  502.         }
  503.         break;
  504.  
  505.     case 3:        /* export; dump to output new version */
  506.         s = symtabFind(symtab, r->e.label);
  507.         if (! s) {
  508.         fprintf(stderr,"ldrdf: internal error - undefined symbol %s "
  509.             "exported in header of '%s'\n",r->e.label,mod->name);
  510.         continue;
  511.         }
  512.         r->e.offset = s->offset;
  513.         rdfaddheader(newheader,r);
  514.         break;
  515.  
  516.     case 4:        /* DLL record */
  517.         rdfaddheader(newheader,r);        /* copy straight to output */
  518.         break;
  519.     }
  520.     }
  521.     if (rdf_errno != 0) {
  522.     rdfperror("ldrdf",mod->name);
  523.     exit(1);
  524.     }
  525.     collection_reset(&imports);
  526.   }
  527. }
  528.     
  529. /* write_output()    write linked program out to a file */
  530.  
  531. void write_output(char *filename)
  532. {
  533.     FILE        * fp;
  534.     rdfheaderrec    r;
  535.  
  536.     if (verbose) printf("writing output to '%s'\n",filename);
  537.  
  538.     fp = fopen(filename,"wb");
  539.     if (! fp)
  540.     {
  541.     fprintf(stderr,"ldrdf: could not open '%s' for writing\n",filename);
  542.     exit(1);
  543.     }
  544.   
  545.     
  546.     /* add BSS length count to header... */
  547.     if (bsslength)
  548.     {
  549.     r.type = 5;
  550.     r.b.amount = bsslength;
  551.     rdfaddheader(newheader,&r);
  552.     }
  553.  
  554.     /* Write header */
  555.     rdfwriteheader(fp,newheader);
  556.     rdfdoneheader(newheader);
  557.     newheader = NULL;
  558.  
  559.     /* Write text */
  560.     if (fwrite(&textlength,1,4,fp) != 4
  561.     || fwrite(text,1,textlength,fp) !=textlength)
  562.     {
  563.     fprintf(stderr,"ldrdf: error writing %s\n",filename);
  564.     exit(1);
  565.     }
  566.  
  567.     /* Write data */
  568.     if (fwrite(&datalength,1,4,fp) != 4 ||
  569.     fwrite(data,1,datalength,fp) != datalength)
  570.     {
  571.     fprintf (stderr,"ldrdf: error writing %s\n", filename);
  572.     exit(1);
  573.     }
  574.     fclose(fp);
  575. }
  576.  
  577.  
  578. /* main program: interpret command line, and pass parameters on to
  579.  * individual module loaders & the linker
  580.  *
  581.  * Command line format:
  582.  * ldrdf [-o outfile | -x] [-r xxxx] [-v] [--] infile [infile ...]
  583.  *
  584.  * Default action is to output a file named 'aout.rdx'. -x specifies
  585.  * that the linked object program should be executed, rather than
  586.  * written to a file. -r specifies that the object program should
  587.  * be prelocated at address 'xxxx'. This option cannot be used
  588.  * in conjunction with -x.
  589.  */
  590.  
  591. const char *usagemsg = "usage:\n"
  592. " ldrdf [-o outfile | -x] [-a x] [-v] [-p x] [--] infile [infile ...]\n"
  593. "       [-l<libname> ...]\n\n"
  594. " ldrdf -h    displays this message\n"
  595. " ldrdf -r    displays version information\n\n"
  596. "   -o selects output filename (default is aout.rdx)\n"
  597. "   -x causes ldrdx to link & execute rather than write to file\n"
  598. "   -a x causes object program to be statically relocated to address 'x'\n"
  599. "   -v turns on verbose mode\n"
  600. "   -p x causes segments to be aligned (padded) to x byte boundaries\n"
  601. "      (default is 16 bytes)\n"
  602. "   -l<name> causes 'name' to be linked in as a library. Note no search is\n"
  603. "      performed - the entire pathname MUST be specified.\n";
  604.  
  605. void usage(void)
  606. {
  607.   fputs(usagemsg,stderr);
  608. }
  609.  
  610. int main(int argc,char **argv)
  611. {
  612.   char    *ofilename = "aout.rdx";
  613.   long    relocateaddr = -1;    /* -1 if no relocation is to occur */
  614.   int    execute = 0;        /* 1 to execute after linking, 0 otherwise */
  615.   int    procsw = 1;        /* set to 0 by '--' */
  616.   int    tmp;
  617.  
  618.   if (argc == 1) {
  619.     usage();
  620.     exit(1);
  621.   }
  622.  
  623.   /* process command line switches, and add modules specified to linked list
  624.      of modules, keeping track of total memory required to load them */
  625.  
  626.   while(argv++,--argc) {
  627.     if (procsw && !strcmp(*argv,"-h")) {    /* Help command */
  628.       usage(); exit(1);
  629.     }
  630.     else if (procsw && !strcmp(*argv,"-r")) {
  631.       printf("ldrdf version %s (%s) (%s)\n",LDRDF_VERSION,_RDOFF_H,
  632.          sizeof(int) == 2 ? "16 bit" : "32 bit");
  633.       exit(1);
  634.     }
  635.     else if (procsw && !strcmp(*argv,"-o")) {
  636.       ofilename = *++argv;
  637.       --argc;
  638.       if (execute) {
  639.     fprintf(stderr,"ldrdf: -o and -x switches incompatible\n");
  640.     exit(1);
  641.       }
  642.       if (verbose > 1) printf("output filename set to '%s'\n",ofilename);
  643.     }
  644.     else if (procsw && !strcmp(*argv,"-x")) {
  645.       execute++;
  646.       if (verbose > 1) printf("will execute linked object\n");
  647.     }
  648.     else if (procsw && !strcmp(*argv,"-a")) {
  649.       relocateaddr = readnum(*++argv,&tmp);
  650.       --argc;
  651.       if (tmp) {
  652.     fprintf(stderr,"ldrdf: error in parameter to '-a' switch: '%s'\n",
  653.         *argv);
  654.     exit(1);
  655.       }
  656.       if (execute) {
  657.     fprintf(stderr,"ldrdf: -a and -x switches incompatible\n");
  658.     exit(1);
  659.       }
  660.       if (verbose) printf("will relocate to %08lx\n",relocateaddr);
  661.     }
  662.     else if (procsw && !strcmp(*argv,"-v")) {
  663.       verbose++;
  664.       if (verbose == 1) printf("verbose mode selected\n");
  665.     }
  666.     else if (procsw && !strcmp(*argv,"-p")) {
  667.       align = readnum(*++argv,&tmp);
  668.       --argc;
  669.       if (tmp) {
  670.     fprintf(stderr,"ldrdf: error in parameter to '-p' switch: '%s'\n",
  671.         *argv);
  672.     exit(1);
  673.       }
  674.       if (align != 1 && align != 2 && align != 4 && align != 8 && align != 16
  675.       && align != 32 && align != 256) {
  676.     fprintf(stderr,"ldrdf: %d is an invalid alignment factor - must be"
  677.         "1,2,4,8,16 or 256\n",align);
  678.     exit(1);
  679.       }
  680.       if (verbose > 1) printf("alignment %d selected\n",align);
  681.     }
  682.     else if (procsw && !strncmp(*argv,"-l",2)) {
  683.     load_library(*argv + 2);
  684.     }
  685.     else if (procsw && !strcmp(*argv,"--")) {
  686.       procsw = 0;
  687.     }
  688.     else {                    /* is a filename */
  689.       if (verbose > 1) printf("processing module %s\n",*argv);
  690.       loadmodule(*argv);
  691.     }
  692.   }
  693.  
  694.   /* we should be scanning for unresolved references, and removing
  695.      unreferenced modules from the list of modules here, so that
  696.      we know about the final size once libraries have been linked in */
  697.  
  698.   build_symbols();    /* build a global symbol table...           */
  699.  
  700.   scan_libraries();    /* check for imported symbols not in table,
  701.                and ensure the relevant library modules
  702.                are loaded */
  703.  
  704.   load_segments();    /* having calculated size of reqd segments, load
  705.                each rdoff module's segments into memory */
  706.  
  707.   link_segments();    /* step through each module's header, and resolve
  708.                references to the global symbol table.
  709.                This also does local address fixups. */
  710.  
  711.   if (errors) {
  712.     fprintf(stderr,"ldrdf: there were errors - aborted\n");
  713.     exit(errors);
  714.   }
  715.   if (execute) {
  716.     fprintf(stderr,"ldrdf: module execution not yet supported\n");
  717.     exit(1);
  718.   }
  719.   if (relocateaddr != -1) {
  720.     fprintf(stderr,"ldrdf: static relocation not yet supported\n");
  721.     exit(1);
  722.   }
  723.  
  724.   write_output(ofilename);
  725.   return 0;
  726. }
  727.